#pragma once
#include <iostream>
#include <vector>
#include <time.h>
#include <assert.h>
using std::cout;
using std::endl;

static const size_t Max_Bytes = 256 * 1024;

void *&Nextobj(void *obj)
{
    return *(void **)obj;
}

// 管理切分好的小对象的自由链表
class FreeList
{

public:
    void Push(void *obj)
    {
        assert(obj);
        Nextobj(obj) = _freeList;
        _freeList = obj;
        _size++;
    }
    void *Pop()
    {
        assert(_freeList);
        void *obj = _freeList;
        _freeList = Nextobj(_freeList);
        _size--;
        return obj;
    }

private:
    void *_freeList = nullptr;
    size_t _size = 0; // 链表节点个数
};

// 管理对⻬和映射等关系
class SizeClass
{
    // 映射规则
    // 整体控制在最多10%左右的内碎⽚浪费
    // [1,128] 8byte对⻬ freelist[0,16)
    // [128+1,1024] 16byte对⻬ freelist[16,72)
    // [1024+1,8*1024] 128byte对⻬ freelist[72,128)
    // [8*1024+1,64*1024] 1024byte对⻬ freelist[128,184)
    // [64*1024+1,256*1024] 8*1024byte对⻬ freelist[184,208)
public:
    // 对所需内存字节数向上取整
    // size_t _RoundUp(size_t bytes, size_t alignNum)
    // {
    //     return ((bytes + alignNum - 1) / alignNum) * alignNum;
    // }

    static inline size_t _RoundUp(size_t bytes, size_t alignNum)
    {
        return (((bytes) + alignNum - 1) & ~(alignNum - 1));
    }

    size_t RoundUp(size_t size)
    {
        if (size <= 128)
        {
            return _RoundUp(size, 8);
        }
        else if (size <= 1024)
        {
            return _RoundUp(size, 16);
        }
        else if (size <= 8 * 1024)
        {
            return _RoundUp(size, 128);
        }
        else if (size <= 64 * 1024)
        {
            return _RoundUp(size, 1024);
        }
        else if (size <= 256 * 1024)
        {
            return _RoundUp(size, 8 * 1024);
        }
        else{
            //超过MAX_BYTES的情况
            return -1;
        }
    }

private:
};